const StudentModel = require('../models/StudentModel')
const jwt = require('jsonwebtoken');
const secret = require('../config/secret');
const bcrypt = require('bcryptjs');
const util = require('util')
const verify = util.promisify(jwt.verify)

class Student {
    /**
     * 搜索文章
     * @param ctx keyword      关键字
     *
     * @returns  返回匹配文章标题的文章列表数据
     */
    static async search(ctx) {

        let {keyword} = ctx.query
        try {
            let data = await StudentModel.search({keyword});
            ctx.response.status = 200;
            ctx.body = {
                code: 200,
                message: `查询成功`,
                data
            }

        } catch (err) {
            console.log(err)
            ctx.response.status = 500;
            ctx.body = {
                code: 500,
                message: `搜索失败`,
                data: err
            }
        }
    }

    /**
     * 获取文章列表
     * @param ctx
     *
     * @returns 文章列表数据
     */
    static async list(ctx) {
        let params = ctx.query;
        try {
            let data = await StudentModel.list(params);

            // data.data.forEach(item => {
            //     item.mobile1 = item.mobile.substr(0,3)+'****'+item.mobile.substr(6,4)
            // })

            // for(let i = 0; i < data.data.length; i++){
            //     data.data[i].mobile_s = data.data[i].mobile.substr(0,3)+'****'+data.data[i].mobile.substr(6,4)
            // }
            //
            // console.log('111111111111111111111'+JSON.stringify(data.data))

            ctx.response.status = 200;
            ctx.body = {
                code: 200,
                message: `查询学生列表成功`,
                data
            }

        } catch (err) {
            ctx.response.status = 500;
            ctx.body = {
                code: 500,
                message: `查询学生列表失败`,
                data: err
            }
        }
    }


    /**
     * 软删除文章数据（隐藏数据）
     * @param ctx id 文章ID
     * @param ctx is_del 是否软删除
     * @returns {Promise<boolean>}
     */
    static async hidden(ctx) {
        console.log('--------------------'+JSON.stringify(ctx.params))
        let {id} = ctx.params;
        let {is_del} = ctx.query;
        console.log('--------------------'+id)

        // 检测是否传入ID
        if (!id) {
            ctx.response.status = 412;
            ctx.body = {
                code: 412,
                message: `ID不能为空`
            }

            return false;
        }

        if (isNaN(id)) {
            ctx.response.status = 412;
            ctx.body = {
                code: 412,
                message: `请传入正确的ID`
            }

            return false;
        }

        try {
            await StudentModel.hidden(id, {is_del});

            ctx.response.status = 200;
            ctx.body = {
                code: 200,
                message: `删除成功`
            }

        } catch (err) {
            ctx.response.status = 500;
            ctx.body = {
                code: 500,
                message: `删除失败`,
                data: err
            }
        }

    }

    /**
     * 更新导航条数据
     * @param ctx title            文章标题
     * @param ctx introduction     文章简介
     * @param ctx categoryId       文章分类ID
     * @param ctx tag              文章标签
     * @param ctx cover            文章封面
     * @param ctx content          文章内容
     *
     * @returns 更新成功则返回更新后的文章数据，失败返回更新失败的原因
     */
    static async update(ctx) {
        let {id} = ctx.params;

        // 检测是否传入ID
        if (!id) {
            ctx.response.status = 412;
            ctx.body = {
                code: 412,
                message: `ID不能为空`
            }

            return false;
        }

        if (isNaN(id)) {
            ctx.response.status = 412;
            ctx.body = {
                code: 412,
                message: `请传入正确的ID`
            }

            return false;
        }

        // 接收参数
        let {name, school, education, mobile, status, teacher, password} = ctx.request.body;

        let params = {
            name,
            school,
            education,
            mobile,
            status,
            teacher,
            password
        }

        try {
            await StudentModel.update(id, params);


            ctx.response.status = 200;
            ctx.body = {
                code: 500,
                message: `更新成功`
            }

        } catch (err) {
            ctx.response.status = 500;
            ctx.body = {
                code: 500,
                message: `更新失败`,
                data: err
            }
        }
    }

    /**
     * 查询用户信息
     * @param ctx token 分发的用户token
     *
     * @returns 查询成功返回用户信息，失败返回错误原因
     */
    static async info(ctx) {
        // 获取jwt
        const token = ctx.header.authorization;

        if (!token) {
            ctx.response.status = 403;
            ctx.body = {
                code: 403,
                message: "Headers Token不能为空"
            }
        }

        let payload
        try {
            // 解密payload，获取用户名和ID
            payload = await verify(token.split(' ')[1], secret.sign)
            const user = {
                id: payload.id,
                mobile: payload.mobile,
                name: payload.name
            }

            ctx.response.status = 200;
            ctx.body = {
                code: 200,
                message: '查询成功！',
                data: user
            }

        } catch (err) {
            ctx.response.status = 500;
            ctx.body = {
                code: 500,
                message: err
            }
        }
    }

    /**
     * 登录
     * @param ctx username     用户名字
     * @param ctx password     用户密码
     *
     * @returns 登录成功返回用户信息，失败返回错误原因
     */
    static async login(ctx) {
        const {mobile , password} = ctx.request.body
        // 查询用户
        const userDetail = await StudentModel.mobile(mobile)

        if (!userDetail) {
            ctx.response.status = 403;
            ctx.body = {
                code: 403,
                message: "用户不存在"
            }

            return false;
        }


        // 判断前端传递的用户密码是否与数据库密码一致
        if (bcrypt.compareSync(password, userDetail.password)) {
            // 用户token
            const userToken = {
                mobile: userDetail.mobile,
                id: userDetail.id,
                name: userDetail.name,
            }

            // 签发token
            const token = jwt.sign(userToken, secret.sign, {expiresIn: '2h'});

            ctx.response.status = 200;
            ctx.body = {
                code: 200,
                message: "登录成功",
                data: {
                    id: userDetail.id,
                    mobile: userDetail.mobile,
                    name: userDetail.name,
                    token: token
                }
            }

        } else {
            ctx.response.status = 401;
            ctx.body = {
                code: 401,
                message: "用户名或密码错误"
            }
        }
    }

    /**
     * 创建文章
     * @param ctx title            文章标题
     * @param ctx introduction     文章简介
     * @param ctx categoryId       文章分类ID
     * @param ctx tag              文章标签
     * @param ctx cover            文章封面
     * @param ctx content          文章内容
     *
     * @returns  成功创建文章返回文章详情数据，失败返回错误信息
     */
    static async create(ctx) {
        // 接收参数
        let {name, school, education, mobile,password, status=1} = ctx.request.body;

        let params = {
            name, school, education, mobile,password, status
        }

        // 检测参数是否存在为空
        let errors = [];
        // for (let item in params) {
        //     if (params[item] === undefined) {
        //         let index = errors.length + 1;
        //         errors.push("错误" + index + ": 参数: " + item + "不能为空")
        //     }
        // }

        if (errors.length > 0) {
            ctx.response.status = 422;
            ctx.body = {
                code: 422,
                message: errors
            }

            return false;
        }

        // 查询用户名是否重复
        const existMobile = await StudentModel.mobile(params.mobile)

        if (existMobile) {
            ctx.response.status = 403;
            ctx.body = {
                code: 403,
                message: "该手机号已注册"
            }

        }else{
            try {
                if(params.password){
                    // 加密密码
                    const salt = bcrypt.genSaltSync();
                    const hash = bcrypt.hashSync(params.password, salt);
                    params.password = hash;
                }


                // 创建文章
                const {id} = await StudentModel.create(params);

                ctx.response.status = 200;
                ctx.body = {
                    code: 200,
                    message: `已提交！`,
                }

            } catch (err) {
                ctx.response.status = 500;
                ctx.body = {
                    code: 500,
                    message: `申请失败`,
                    data: err
                }
            }
        }



    }
}

module.exports = Student
